home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / gawk / cawf2st.zoo / expand.c < prev    next >
C/C++ Source or Header  |  1992-04-12  |  12KB  |  285 lines
  1. /*
  2.  *      expand.c - macro expansion functions for cawf(1)
  3.  */
  4.  
  5. /*
  6.  *      Copyright (c) 1991 Purdue University Research Foundation,
  7.  *      West Lafayette, Indiana 47907.  All rights reserved.
  8.  *
  9.  *      Written by Victor A. Abell <abe@mace.cc.purdue.edu>,  Purdue
  10.  *      University Computing Center.  Not derived from licensed software;
  11.  *      derived from awf(1) by Henry Spencer of the University of Toronto.
  12.  *
  13.  *      Permission is granted to anyone to use this software for any
  14.  *      purpose on any computer system, and to alter it and redistribute
  15.  *      it freely, subject to the following restrictions:
  16.  *
  17.  *      1. The author is not responsible for any consequences of use of
  18.  *         this software, even if they arise from flaws in it.
  19.  *
  20.  *      2. The origin of this software must not be misrepresented, either
  21.  *         by explicit claim or by omission.  Credits must appear in the
  22.  *         documentation.
  23.  *
  24.  *      3. Altered versions must be plainly marked as such, and must not
  25.  *         be misrepresented as being the original software.  Credits must
  26.  *         appear in the documentation.
  27.  *
  28.  *      4. This notice may not be removed or altered.
  29.  */
  30.  
  31. #include "cawf.h"
  32. #include <string.h>
  33.  
  34. /*
  35.  * Expand(line) - expand macro or if/ie/el line
  36.  */
  37.  
  38. Expand(line)
  39.         char *line;
  40. {
  41.         char buf[2*MAXLINE];            /* line buffer */
  42.         char cmd[4];                    /* nroff command */
  43.         int cmdl;                       /* command length */
  44.         int cmdx;                      /* cmd index in Macrotab[] */
  45.         int cond = 0;                   /* conditional statuses */
  46.         int i, j;                       /* temporary indexes */
  47.         int iflen;                      /* if statement length */
  48.         int invert;                     /* inversion status */
  49.         char *lp;                       /* line pointer */
  50.         int mx = -1;                    /* Macrotab[] index */
  51.         int n1, n2;                     /* temporary numbers */
  52.         int nargs = 0;                  /* number of arguments */
  53.         int nleft = 0;                  /* number of macro lines left */
  54.         int prevcond;                   /* previous condition (for else's) */
  55.         int ptr = -1;                   /* Macrotxt[] index */
  56.         int quote;                      /* quoted string status */
  57.         char *s1, *s2;                  /* temporary string pointers */
  58.  
  59.  
  60.         (void) sprintf(buf, ".^= %d %s", NR, Inname);
  61.         Pass2(buf);
  62.  
  63.         for (lp = line; *lp; ) {
  64.                 invert = regexec(Pat[1].pat, lp);
  65.                 prevcond = cond;
  66.                 cond = 0;
  67.                 if (regexec(Pat[0].pat, lp) == 0) {
  68.             /*
  69.              * Not conditional: - ! "^\.(i[ef]|el)"
  70.              */
  71.                         cond = 1;
  72.                         iflen = 0;
  73.                 }
  74.  
  75.                 else if (regexec(Pat[2].pat, lp)) {
  76.             /*
  77.              * Argument count comparison: - "^\.i[ef] !?\\n\(\.\$[<=>][0-9] "
  78.              */
  79.                         iflen = strlen(".if \\n(.$=n ") + invert;
  80.                         n1 = (int)(*(lp + iflen - 2) - '0');
  81.                         switch (*(lp + iflen - 3)) {
  82.                                 case '=':
  83.                                         if ((nargs - 1) == n1)
  84.                                                 cond = 1;
  85.                                         break;
  86.                                 case '<':
  87.                                         if ((nargs - 1) < n1)
  88.                                                 cond = 1;
  89.                                         break;
  90.                                 case '>':
  91.                                         if ((nargs - 1) > n1)
  92.                                                 cond = 1;
  93.                                         break;
  94.                         }
  95.                 }
  96.                 
  97.                 else if (regexec(Pat[3].pat, lp)) {
  98.             /*
  99.              * Argument string comparison: - "^\.i[ef] !?'\\\$[0-9]'[^']*' "
  100.              */
  101.                         iflen = strlen(".if '\\$n'") + invert;
  102.                         n1 = (int)(*(lp + iflen - 2) - '0');
  103.                         if (n1 >= 0 && n1 < nargs)
  104.                                 s1 = Args[n1];
  105.                         else
  106.                                 s1 = "";
  107.                         if ((s2 = strchr(lp + iflen, '\'')) != NULL) {
  108.                                 n2 = s2 - lp - iflen;
  109.                                 if (strncmp(s1, lp + iflen, n2) == 0)
  110.                                         cond = 1;
  111.                                 iflen += n2 + 2;
  112.                         }
  113.                 }
  114.                 
  115.                 else if (regexec(Pat[4].pat, lp)) {
  116.             /*
  117.              * Nroff or troff: - "^\.i[ef] !?[nt] "
  118.              */
  119.                         iflen = strlen(".if n ") + invert;
  120.                         if (*(lp + iflen - 2) == 'n')
  121.                                 cond = 1;
  122.                 }
  123.                 
  124.                 else if (strncmp(lp, ".el ", 4) == 0) {
  125.             /*
  126.              * Else clause: - "^\.el "
  127.              */
  128.                         cond = 1 - prevcond;
  129.                         iflen = 4;
  130.                 }
  131.                 
  132.                 else {
  133.             /*
  134.              * Unknown conditional:
  135.              */
  136.                         cond = 1;
  137.                         iflen = 0;
  138.                         (void) sprintf(buf, ".tm unknown .if/.ie form: %s", lp);
  139.                         lp = buf;
  140.                 }
  141.            /*
  142.             * Handle conditional.  If case is true, locate predicate.
  143.             * If predicate is an .i[ef], process it.
  144.             */
  145.                 if (invert)
  146.                         cond = 1 - cond;
  147.                 if (cond && iflen > 0) {
  148.                         lp += iflen;
  149.                         if (regexec(Pat[15].pat, lp))
  150.                                 continue;
  151.                 }
  152.             /*
  153.              * Do argument substitution, as necessary.
  154.              */
  155.                 if (cond && regexec(Pat[5].pat, lp)) {      /* "\$[0-9]" ??? */
  156.                         for (s1 = buf;;) {
  157.                                 if ((n1 = Pat[5].pat->startp[0] - lp) > 0) {
  158.                                         (void) strncpy(s1, lp, n1);
  159.                                         s1 += n1;
  160.                                 }
  161.                                 *s1 = '\0';
  162.                                 lp = Pat[5].pat->endp[0];
  163.                                 n1 = (int)(*(lp-1) - '0');
  164.                                 if (n1 >= 0 && n1 < nargs) {
  165.                                         (void) strcpy(s1, Args[n1]);
  166.                                         s1 += strlen(Args[n1]);
  167.                                 }
  168.                                 if (*lp == '\0')
  169.                                         break;
  170.                                 if (regexec(Pat[5].pat, lp) == 0) {
  171.                                         (void) strcpy(s1, lp);
  172.                                         break;
  173.                                 }
  174.                         }
  175.                         lp = buf;
  176.                 }
  177.             /*
  178.              * Check for nroff command.
  179.              */
  180.                 if (cond) {
  181.                         cmdl = 0;
  182.                         if (cond && *lp == '.') {
  183.                                 if ((*cmd = *(lp+1)) != '\0') {
  184.                                         cmdl++;
  185.                                         if ((*(cmd+1) = *(lp+2)) == ' ')
  186.                                                 *(cmd+1) = '\0';
  187.                                         else
  188.                                                 cmdl++;
  189.                                 }
  190.                         }
  191.                         cmd[cmdl] = '\0';
  192.                 }
  193.                 if (cond == 0)
  194.                         i = i;          /* do nothing if condition is false */
  195.                 else if (cmdl == 0 || ((cmdx = Findmacro(cmd, 0)) < 0))
  196.                         Pass2(lp);
  197.                 else if (Sp >= MAXSP) {
  198.                         (void) sprintf(buf, " macro nesting > %d", MAXSP);
  199.